package app.controllers;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.springframework.util.StringUtils;

import app.models.Consulta;
import app.models.Especialidade;
import app.models.Funcionario;
import app.models.Observacao;
import app.models.Paciente;
import app.models.ParametroSistema;
import app.models.SubEspecialidade;
import app.models.enums.DiasSemana;
import app.models.enums.StatusBiometria;
import app.models.enums.StatusConsulta;
import app.models.enums.TipoConsulta;
import app.services.ConsultaService;
import app.services.ConvenioService;
import app.services.EspecialidadeService;
import app.services.FuncionarioService;
import app.services.LogService;
import app.services.ObservacaoService;
import app.services.PacienteService;
import app.services.ParametroSistemasService;
import app.services.SubEspecialidadeService;
import app.services.UsuarioService;
import app.session.UserSession;
import app.util.Constants;
import app.util.DateUtils;
import br.com.caelum.vraptor.Get;
import br.com.caelum.vraptor.Post;
import br.com.caelum.vraptor.Resource;
import br.com.caelum.vraptor.Result;
import br.com.caelum.vraptor.Validator;
import br.com.caelum.vraptor.validator.ValidationMessage;

@Resource
public class ConsultaController extends Controller {

	private final Result result;
	private final ConsultaService service;
	private final PacienteService pacienteService;
	private final FuncionarioService funcionarioService;
	private final EspecialidadeService especialidadeService;
	private final SubEspecialidadeService subEspecialidadeService;
	private final ConvenioService convenioService;
	private final UserSession userSession;
	private final Validator validator;
	private final HttpServletRequest request;
	private final ParametroSistemasService parametroSistemasService;
	private final LogService logService;
	private final UsuarioService usuarioService;
	private final ObservacaoService observacaoService;
	
	public ConsultaController(Result result,
			ConsultaService service, Validator validator,
			PacienteService pacienteService,
			FuncionarioService funcionarioService,
			EspecialidadeService especialidadeService,
			SubEspecialidadeService subEspecialidadeService,
			ConvenioService convenioService,
			UserSession userSession,
			HttpServletRequest request,
			ParametroSistemasService parametroSistemasService, LogService logService, UsuarioService usuarioService, ObservacaoService observacaoService) {

		this.result = result;
		this.service = service;
		this.validator = validator;
		this.pacienteService = pacienteService;
		this.funcionarioService = funcionarioService;
		this.especialidadeService = especialidadeService;
		this.subEspecialidadeService = subEspecialidadeService;
		this.convenioService = convenioService;
		this.userSession = userSession;
		this.request = request;
		this.parametroSistemasService = parametroSistemasService;
		this.logService = logService;
		this.usuarioService = usuarioService;
		this.observacaoService = observacaoService;
	}
	
	@Get("/consultas")
	public void index() {
		
		Integer month = DateUtils.getMesAtual();
		Integer year = DateUtils.getAnoAtual();
		
		result.include("today", DateUtils.getDiaAtual());
		result.include("month", month);
		result.include("year", year);
		result.include("monthName", DateUtils.getMonthName(DateUtils.getMesAtual()));
		
		month -= 1;
		
		// relação consultas/dia
		result.include("consultasDiarias", service.findConsultasInDayOnMonth(null, month, year));
		
		// primeiro dia da semana do mês atual
		result.include("firstWeekDay", service.findFirstWeekDay(null, null));
		
		// quantidade de dias do mês atual
		result.include("lastMonthDay", service.findLastMonthDay(null, null));
		
		// todos os dias da semana
		result.include("weekDays", DiasSemana.values());
	}
	
	@Get("/consultas/{month}/{year}")
	public void index(Consulta consulta, Integer month, Integer year) {
		
		result.include("tipos", TipoConsulta.values());
		result.include("month", month);
		result.include("year", year);
		result.include("monthName", DateUtils.getMonthName(month));
		
		// Limpar filtros da tela
		if (null != request.getParameter("submit")) {
			if (request.getParameter("submit").equals("Limpar")) {
				consulta = new Consulta();
			}
		}
		
		// Calendar inicia o ano com primeiro mês = 0.
		month -= 1;
		
		// relação consultas/dia
		consulta.setStatus(null);
		result.include("consultasDiarias", service.findConsultasInDayOnMonth(consulta, month, year));
		
		// primeiro dia da semana do mês/ano atual
		result.include("firstWeekDay", service.findFirstWeekDay(month, year));
		
		// quantidade de dias do mês/ano atual
		result.include("lastMonthDay", service.findLastMonthDay(month, year));
		
		// todos os dias da semana
		result.include("weekDays", DiasSemana.values());

		// filtros do calendário
		result.include("consulta", consulta);
		
		if (consulta.getTipo() == TipoConsulta.PARTICULAR) {
			List<Especialidade> especialidades = especialidadeService.findAllOrdered();
			
			result.include("especialidades", especialidades);
				
		} else if (consulta.getTipo() == TipoConsulta.CONVENIO) {
			List<SubEspecialidade> subEspecialidades = subEspecialidadeService.findAllOrdered();
			
			result.include("subEspecialidades", subEspecialidades);
		}
		
		List<Funcionario> especialistas = funcionarioService.findAllOrdered();
		
		if (null != consulta.getEspecialidade()) {
			result.include("especialistas", funcionarioService.findEspecialistasByEspecialidade(consulta.getEspecialidade().getId()));
		} else if (null != consulta.getSubEspecialidade()) {
			result.include("especialistas", funcionarioService.findEspecialistasByEspecialidade(Long.valueOf(consulta.getSubEspecialidade().getEspecialidade().getId())));
		} else {
			result.include("especialistas", especialistas);
		}
		
		validator.onErrorRedirectTo(this).sendErrorsToScreen(consulta, null, month, year);
	}
	
	@Get("/consultas/calendario/{action}/{year}")
	public void index(String action, Integer year) {
		if (action.equals("proximo")) {
			result.include("year", year + 1);
		} else if (action.equals("anterior")) {
			result.include("year", year - 1);
		}
	}
	
	@Get("/consultas/{mDay}/{month}/{year}")
	public void formHorario(Consulta consulta, Integer mDay, Integer month, Integer year) {

		result.include("mDay", mDay);
		result.include("month", month);
		result.include("year", year);
		result.include("validarDataSelecionada", service.validateIfDateIsGreaterEqualToday(mDay, month, year));
		
		if (null != request.getParameter("submit")) {
			if (request.getParameter("submit").contains("marcar_consulta")) {
				Integer hora = Integer.valueOf(StringUtils.replace(request.getParameter("submit"), "marcar_consulta_", ""));
				
				consulta.setData(year + "-" + DateUtils.formatMonth(month) + "-" + mDay);
				consulta.setHoraInicial(hora + ":00:00");
				consulta.setHoraFinal((hora + 1) + ":00:00");
				
				result.forwardTo(this).form(consulta, month, year, null);
			}
		}
		
		result.include("tiposConsultas", TipoConsulta.values());
		result.include("weekDayName", DateUtils.getWeekDayName(DateUtils.getWeekDay(mDay, month, year)));
		result.include("monthName", DateUtils.getMonthName(month));
		
		// Limpar filtros da tela
		if (null != request.getParameter("submit")) {
			if (request.getParameter("submit").equals("Limpar")) {
				consulta = new Consulta();
			}
		}
		
		Map<Integer, List<Consulta>> listaConsultasPorHora = service.findConsultasInHour(consulta, mDay, (month - 1), year);
		result.include("listaConsultasPorHora", listaConsultasPorHora);
		
		consulta.setData(year + "-" + DateUtils.formatMonth(month) + "-" + mDay);
		
		if (consulta.getTipo() == TipoConsulta.PARTICULAR) {
			List<Especialidade> especialidades = especialidadeService.findAllOrdered();
			
			result.include("especialidades", especialidades);
			
		} else if (consulta.getTipo() == TipoConsulta.CONVENIO) {
			List<SubEspecialidade> subEspecialidades = subEspecialidadeService.findAllOrdered();
			
			result.include("subEspecialidades", subEspecialidades);
		}
		
		List<Funcionario> especialistas = funcionarioService.findAllOrdered();
		
		if (null != consulta.getIdEspecialidade()) {
			Especialidade especialidade = especialidadeService.find(consulta.getIdEspecialidade().longValue());
				
			result.include("especialistas", funcionarioService.findEspecialistasByEspecialidade(especialidade.getId()));
		} else if (null != consulta.getIdSubEspecialidade()) {
			SubEspecialidade subEspecialidade = subEspecialidadeService.find(consulta.getIdSubEspecialidade().longValue());
				
			result.include("especialistas", funcionarioService.findEspecialistasByEspecialidade(Long.valueOf(subEspecialidade.getEspecialidade().getId())));
		} else {
			result.include("especialistas", especialistas);
		}
		
		result.include("consulta", consulta);
		
		validator.onErrorForwardTo(this).sendErrorsToScreen(consulta, mDay, month, year);
	}

	@Get("/consultas/new/{month}/{year}")
	public void form(Consulta consulta, Integer month, Integer year, Observacao observacao) {
		
		Paciente paciente = null;
		
		consulta = service.replaceCommaForPoint(consulta);
		
		if(consulta.getIdPaciente() != null){
			paciente = pacienteService.find(consulta.getIdPaciente().longValue());
			if (null == request.getParameter("submit")) {
				observacao = observacaoService.findByUsuarioId(paciente.getUsuario().getId().intValue());
			} else {
				observacao.setIdUsuario(paciente.getUsuario().getId().intValue());
			}
		}
		
		if (null != request.getParameter("submit")) {
			if (request.getParameter("submit").equals("Observacao")) {
				if(observacao.getId() != null){
					observacaoService.update(observacao);
					
					logService.createLog(Constants.UPDATE_OBSERVACAO + observacao.getId());
				} else {
					observacaoService.create(observacao);
					
					logService.createLog(Constants.NEW_OBSERVACAO + observacao.getId());
				}
			}
		}
		
		result.include("observacao", observacao);
		result.include("month", month);
		result.include("year", year);
		result.include("userSession", userSession.getUser());
		
		if (null != request.getParameter("form")) {
			if (request.getParameter("form").equals("modalForm")) {
				if(consulta.getIdEspecialista() != null && consulta.getIdEspecialista() != 0){
					Funcionario especialista = funcionarioService.find(consulta.getIdEspecialista().longValue());
					consulta.setEspecialista(especialista);
					consulta.setIdEspecialista(especialista.getId().intValue());
				}
				
				if (consulta.isFlagPagou()) {
					consulta.setDataPagamento(DateUtils.getDataAtual());
					consulta.setStatus(StatusConsulta.PAGA);
				}
			} else {
				result.include("tipos", TipoConsulta.values());
				result.include("convenios", convenioService.findAll());
				result.include("pacientes", pacienteService.findAllOrderedWithoutMax());
				
				if (consulta.getTipo() == TipoConsulta.PARTICULAR) {
					List<Especialidade> especialidades = especialidadeService.findAllOrdered();
					
					result.include("especialidades", especialidades);
					
				} else if (consulta.getTipo() == TipoConsulta.CONVENIO) {
					if(consulta.getIdConvenio() != null){
						List<SubEspecialidade> subEspecialidades = subEspecialidadeService.findAllByConvenio(consulta.getIdConvenio());
						
						result.include("subEspecialidades", subEspecialidades);
					}
				}
			}
		}
		
		List<Funcionario> especialistas = funcionarioService.findAllOrdered();
		
		if (null != consulta.getIdEspecialidade()) {
			Especialidade especialidade = especialidadeService.find(consulta.getIdEspecialidade().longValue());
			
			consulta.setValor(especialidade.getValor());
			
			especialistas = funcionarioService.findEspecialistasByEspecialidade(especialidade.getId());
			
			result.include("especialistas", especialistas);
			
		} else if (null != consulta.getIdSubEspecialidade()) {
			SubEspecialidade subEspecialidade = subEspecialidadeService.find(consulta.getIdSubEspecialidade().longValue());
			
			consulta.setValor(subEspecialidade.getValor());
			
			especialistas = funcionarioService.findAllEspecialistasByEspecialidade(subEspecialidade.getEspecialidade().getId().intValue());
			
			result.include("especialistas", especialistas);
			
		} else {
			consulta.setValor(0.0);
			
			result.include("especialistas", especialistas);
		}
		
		result.include("consulta", consulta);
		
		if (null != request.getParameter("filterPaciente")) {
			result.include("filterPaciente", request.getParameter("filterPaciente").toString());
			result.include("pacientesFilter", pacienteService.findPacientesByFilter(request.getParameter("filterPaciente").toString()));
			
			if (null != request.getParameter("aux")) {
				if (request.getParameter("aux").equals("filterPaciente")) {
					result.include("aux", request.getParameter("aux").toString());
					
					if (request.getParameter("filterPaciente").equals("")) {
						result.nothing();
					} else {
						result.forwardTo("/WEB-INF/jsp/consulta/pacienteFilter.jsp");
					}
				} else if (request.getParameter("aux").equals("filterDefault")) {
					
					result.include("aux", request.getParameter("aux").toString());
				}
			}
		}
		
		if (null != request.getParameter("submit")) {
			if (request.getParameter("submit").equals("Agendar")) {
				validator.validate(consulta);
				validator.onErrorForwardTo(this).form(consulta, month, year, null);
			} else if (!request.getParameter("submit").contains("marcar_consulta") && !request.getParameter("submit").equals("Agendar") && !request.getParameter("submit").equals("Observacao")) {
				validator.validate(consulta);
				validator.onErrorForwardTo(this).form(consulta.getId());
			}
			
			if (request.getParameter("submit").equals("Agendar") || request.getParameter("submit").equals("Iniciar")) {
				result.forwardTo(this).createOrInitConsulta(consulta, month, year);
			} else if (request.getParameter("submit").equals("Confirmar")) {
				result.forwardTo(this).iniciaConsulta(consulta);
			} else if (!request.getParameter("submit").contains("marcar_consulta") && !request.getParameter("submit").equals("Agendar") && !request.getParameter("submit").equals("Observacao")) {
				validator.onErrorForwardTo(this).fields();
			}
			
		} else if (null != request.getParameter("hasFilter")) {
			if (request.getParameter("hasFilter").equals("Sim")) {
				validator.validate(consulta);
				validator.onErrorForwardTo(this).fields();
			}
		}
		
		validator.onErrorForwardTo(this).form(consulta, month, year, null);
	}
	
	@Get("/consultas/save/{month}/{year}/{hour}")
	public void createOrInitConsulta(Consulta consulta, Integer month, Integer year) {
		Paciente paciente = pacienteService.find(consulta.getIdPaciente().longValue());
		
		Funcionario funcionario = funcionarioService.find(consulta.getIdEspecialista().longValue());
		
		if(service.verifyLatePayments(consulta.getIdPaciente())){
			validator.add(new ValidationMessage(bundle.getString("paciente.hasLatePayments"), Constants.ERROR));
		}
		
		if(service.validateMaxConsultNumberByHour(consulta)){
			validator.add(new ValidationMessage(bundle.getString("numMaxDeConsultas.exceeded"), Constants.ERROR));
		}
		
		if (service.verifyEspecialistasConsults(consulta)){
			validator.add(new ValidationMessage(bundle.getString("especialista.unavaible"), Constants.ERROR));
		}
		
		if (null != consulta.getTipo()) {
			if (consulta.getTipo().equals(TipoConsulta.CONVENIO)) {
				if (null == consulta.getIdConvenio()) {
					validator.add(new ValidationMessage("convenio.empty", Constants.ERROR));
				}
			}
		}
		
		if(!usuarioService.verifyIfUsuarioIsActive(funcionario.getUsuario().getId().longValue())){
			validator.add(new ValidationMessage(bundle.getString("funcionario.inactive"), Constants.ERROR));
		}
		
		if(!usuarioService.verifyIfUsuarioIsActive(paciente.getUsuario().getId().longValue())){
			validator.add(new ValidationMessage(bundle.getString("paciente.inactive"), Constants.ERROR));
		}

		validator.validate(pacienteService.find(consulta.getIdPaciente().longValue()));
		
		validator.validate(pacienteService.find(consulta.getIdPaciente().longValue()).getUsuario());
		
		validator.validate(funcionarioService.find(consulta.getIdEspecialista().longValue()));
		
		validator.validate(funcionarioService.find(consulta.getIdEspecialista().longValue()).getUsuario());
		
		consulta = service.setValueAndDiscount(consulta);
		
		consulta = service.setStatusConsultaBeforeSave(consulta);
		
		validator.validate(consulta);
		
		validator.onErrorForwardTo(this).form(consulta);
		
		service.create(consulta);
		
		logService.createLog(Constants.NEW_CONSULTA + consulta.getId());
		
		//verifica se a consulta esta sendo iniciada ou marcada
		if (null != request.getParameter("typeNewConsulta") && !request.getParameter("typeNewConsulta").isEmpty()) {
			if(Integer.valueOf(request.getParameter("typeNewConsulta")) == 2){ 
				result.include("consulta", consulta);
				result.forwardTo("/WEB-INF/jsp/consulta/iniciaConsulta.jsp");
			} else {
				result.forwardTo(this).index();
			}
		} else {
			result.forwardTo(this).index();
		}
		
	}
	
	public void form (Consulta consulta){
		result.include("consulta", consulta);
	}
	
	@Get("/consultas/{id}/edit")
	public void form(Long id) {
		Consulta consulta = service.find(id);
		
		result.include("consulta", consulta);
		
		result.include("tipos", TipoConsulta.values());
		result.include("convenios", convenioService.findAll());
		result.include("pacientes", pacienteService.findAllOrderedWithoutMax());
		
		if (consulta.getTipo() == TipoConsulta.CONVENIO) {
			result.include("especialidades", subEspecialidadeService.findAllOrdered());
			result.include("especialistas", funcionarioService.findAllEspecialistasByEspecialidade(consulta.getSubEspecialidade().getEspecialidade().getId().intValue()));
		} else {
			result.include("especialidades", especialidadeService.findAllOrdered());
			result.include("especialistas", funcionarioService.findEspecialistasByEspecialidade(consulta.getIdEspecialidade().longValue()));
		}
		
	}
	
	@Get("/consultas/confirm/{id}")
	public void confirmStart(Long id) {
		logService.createLog(Constants.CONFIRM_CONSULTA + id);
		
		Consulta consulta = service.find(id);
		
		List<Funcionario> especialistas = new ArrayList<Funcionario>();
		
		if (consulta.getTipo() == TipoConsulta.CONVENIO) {
			especialistas = funcionarioService.findEspecialistasByEspecialidade(consulta.getSubEspecialidade().getEspecialidade().getId().longValue());
			
			result.include("especialistas", especialistas);
		} else if (consulta.getTipo() == TipoConsulta.PARTICULAR) {
			especialistas = funcionarioService.findEspecialistasByEspecialidade(consulta.getIdEspecialidade().longValue());
			
			result.include("especialistas", especialistas);
		}
		
		if(!StatusConsulta.PAGA.equals(consulta.getStatus()) && !StatusConsulta.MARCADA.equals(consulta.getStatus())){
			validator.add(new ValidationMessage(bundle.getString("consulta.cannotStart"), Constants.ERROR));
		}
		
		result.include("consulta", consulta);
		
		validator.onErrorForwardTo(this).form(id);
		
		result.forwardTo(this).show();
	}
	
	@Get("/consultas/confirm")
	public void confirm(Consulta consulta) {
		result.include("c", consulta);
	}
	
	@Post("/consultas/compareBiometria")
	public void compareBiometria(Boolean verify, Integer idConsulta) {
		logService.createLog(Constants.COMPARE_BIOMETRIA + idConsulta);
		
		result.nothing();
	}
	
	@Get("/consultas/start/{idConsulta}")
	public void startConsultaAfterBiometriaOrPasswordValidation(Integer idConsulta) {
		
		Consulta consulta = service.find(idConsulta.longValue());
		
		if(StatusBiometria.NAO.equals(consulta.getStatusBiometria())){
			validator.add(new ValidationMessage(bundle.getString("biometriaVerification.failed"), Constants.ERROR));
		}
		
		if(!StatusConsulta.MARCADA.equals(consulta.getStatus()) && !StatusConsulta.PAGA.equals(consulta.getStatus())){
			validator.add(new ValidationMessage(bundle.getString("consulta.alreadyStarted"), Constants.ERROR));
		}
		
		validator.onErrorForwardTo(this).index();
		
		service.startConsulta(consulta);
		
		logService.createLog(Constants.START_CONSULTA + idConsulta);
		
		// IMPLEMENTAR: Gerar nota fiscal
		
		result.forwardTo(this).index();
	}
	
	@Post("/consultas/saveStart")
	public void saveStart(Consulta consulta) {
		validator.validate(consulta);
		validator.onErrorUsePageOf(this).index();
		
		service.create(consulta);
		
		logService.createLog(Constants.SAVE_START_CONSULTA + consulta.getId());
		
		result.include("idConsulta", consulta.getId());
	}
	
	@Get("/consultas/pay/{idConsulta}/{mDay}/{month}/{year}")
	public void payConsulta(Integer idConsulta, Integer mDay, Integer month, Integer year) {
		
		if(service.payConsulta(idConsulta)){
			validator.add(new ValidationMessage(bundle.getString("payConsulta.fail"), Constants.ERROR));
		}
		
		validator.onErrorForwardTo(this).formHorario(new Consulta(), mDay, month, year);
		
		logService.createLog(Constants.PAY_CONSULTA + idConsulta);
		
		result.forwardTo(this).formHorario(new Consulta(), mDay, month, year);
		
		// IMPLEMENTAR: Gerar nota fiscal - não deverá ser obrigatório
	}
	
	
	@Get("/consultas/cancel/{idConsulta}/{mDay}/{month}/{year}")
	public void cancelConsulta(Integer idConsulta, Integer mDay, Integer month, Integer year) {
		
		if(!StatusConsulta.MARCADA.equals(service.find(idConsulta.longValue()).getStatus()) 
				&& !StatusConsulta.PAGA.equals(service.find(idConsulta.longValue()).getStatus())){
			validator.add(new ValidationMessage(bundle.getString("cancelConsulta.fail"), Constants.ERROR));
		}
		
		validator.onErrorForwardTo(this).formHorario(new Consulta(), mDay, month, year);
		
		// Adicionar regra para barrar o cancelamento da consulta se for efetuado o cancelamento em menos de 3 horas antes da consulta, nesse caso mudar o status para cancelada em cima da hora e devera constar que o paciente e devedor		Consulta consulta = service.find(idConsulta.longValue());
		
		service.cancelConsulta(idConsulta);
		
		logService.createLog(Constants.CANCEL_CONSULTA + idConsulta);
		
		result.forwardTo(this).formHorario(new Consulta(), mDay, month, year);
	}
	
	@Get("/iniciaBiometriaModal/{idConsulta}")
	public void iniciaConsulta(Consulta consulta){
		service.update(consulta);
		result.include("consulta", consulta);
	}
	
	@Post("/consultas/verifyPassword/{idConsulta}")
	public void verifySystemPassword(String senha, Long idConsulta){
		
		Consulta consulta = service.find(idConsulta);
		
		ParametroSistema parametroSistema = parametroSistemasService.findByParam(Constants.SENHA_BIOMETRIA);
		
		if(parametroSistema != null){
			if(parametroSistema.getValor().equals(senha)){
				consulta.setStatusBiometria(StatusBiometria.SIM);
			} else {
				consulta.setStatusBiometria(StatusBiometria.NAO);
				validator.add(new ValidationMessage(bundle.getString("systemPassword.incorrect"), Constants.ERROR));
			}
		} else {
			validator.add(new ValidationMessage(bundle.getString("systemPassword.fail"), Constants.ERROR));
		}
		
		result.include("consulta",consulta);
		
		validator.onErrorForwardTo(this).iniciaConsulta(consulta);
		
		service.update(consulta);
		
		logService.createLog(Constants.START_CONSULTA_WITH_PASSWORD + idConsulta);
		
		result.forwardTo(this).iniciaConsulta(consulta);
	}	
	
	@Get("/consultas/modalPagar/{id}/{mDay}/{month}/{year}")
	public void modalPagar(Long id, Integer mDay, Integer month, Integer year) {
		result.include("idConsulta", id);
		result.include("mDay", mDay);
		result.include("month", month);
		result.include("year", year);
	}
	
	@Get("/consultas/modalCancelar/{id}/{mDay}/{month}/{year}")
	public void modalCancelar(Long id, Integer mDay, Integer month, Integer year) {
		result.include("idConsulta", id);
		result.include("mDay", mDay);
		result.include("month", month);
		result.include("year", year);
	}
	
	public void sendErrorsToScreen(Consulta consulta, Integer mDay, Integer month, Integer year) {
		
		result.include("mDay", mDay);
		result.include("month", month);
		result.include("year", year);
		result.include("consulta", consulta);
		
		if (null != mDay) {
			result.forwardTo("/WEB-INF/jsp/consulta/formHorario.jsp");
		} else {
			result.forwardTo("/WEB-INF/jsp/consulta/index.jsp");
		}
	}
	
	// Metódos criados apenas para redirecionamentos de páginas.
	public void form(){}
	public void fields(){}
	public void show(){}
	public void search(Consulta consulta) {}
	
}